Système de Gestion des Communications Téléphoniques (Kali Linux Edition) 📞

Ce programme Python vous permet de gérer les communications téléphoniques (appels, SMS) sur un environnement Kali Linux. Le projet inclut la collecte de métadonnées des appels et SMS, le chiffrement AES des SMS, la capture de paquets réseau et la détection d'anomalies en temps réel.

Fonctionnalités du Programme :

• Chiffrement AES pour les SMS : Les SMS sont chiffrés avec le standard AES avant d'être stockés, garantissant la sécurité des messages.
• Stockage des métadonnées en JSON : Les métadonnées des appels et SMS sont stockées dans un fichier JSON facile à exploiter pour l'analyse.
• Capture de paquets réseau : Utilisation de Scapy pour capturer le trafic réseau et analyser les paquets en temps réel.
• Détection d'anomalies : Surveillance des pics d'activité dans les appels et envoi d'alertes si un seuil est dépassé.
• Visualisation avec Matplotlib : Un graphique des communications est généré pour une meilleure compréhension des données.
• Multi-tâches : Le programme exécute la capture réseau et la détection d'anomalies en parallèle grâce au threading.

Code Python :

import datetime
import smtplib
from scapy.all import sniff
import threading
import matplotlib.pyplot as plt
from Crypto.Cipher import AES
import base64
import os
import json

# Fichier pour stocker les métadonnées des communications
COMM_FILE = 'telecom_metadata_kali.json'

# Clé et configuration AES pour chiffrer les SMS
AES_KEY = os.urandom(16)  # Génère une clé AES aléatoire de 16 octets
AES_IV = os.urandom(16)   # Génère un vecteur d'initialisation aléatoire

# Fonction pour chiffrer les messages avec AES
def encrypt_message_aes(message):
    cipher = AES.new(AES_KEY, AES.MODE_CFB, AES_IV)
    encrypted = base64.b64encode(cipher.encrypt(message.encode()))
    return encrypted.decode()

# Fonction pour déchiffrer les messages avec AES
def decrypt_message_aes(encrypted_message):
    cipher = AES.new(AES_KEY, AES.MODE_CFB, AES_IV)
    decrypted = cipher.decrypt(base64.b64decode(encrypted_message.encode()))
    return decrypted.decode()

# Fonction pour stocker les métadonnées des appels/SMS dans un fichier JSON
def store_metadata(type_comm, sender, receiver, timestamp, duration=None, sms_content=None):
    entry = {
        'timestamp': timestamp,
        'type_comm': type_comm,
        'sender': sender,
        'receiver': receiver,
        'duration': duration,
        'sms_content': sms_content
    }
    
    # Lecture et écriture du fichier JSON
    try:
        with open(COMM_FILE, 'r') as file:
            data = json.load(file)
    except FileNotFoundError:
        data = []

    data.append(entry)

    with open(COMM_FILE, 'w') as file:
        json.dump(data, file, indent=4)

# Fonction pour lire et afficher toutes les métadonnées enregistrées
def list_metadata():
    try:
        with open(COMM_FILE, 'r') as file:
            data = json.load(file)
            if not data:
                print("Aucune communication enregistrée.")
            else:
                for entry in data:
                    print(f"{entry['timestamp']} - {entry['type_comm']} - De: {entry['sender']} à {entry['receiver']} - Durée: {entry.get('duration', 'N/A')} - Message: {entry.get('sms_content', 'N/A')}")
    except FileNotFoundError:
        print("Le fichier de métadonnées est introuvable.")

# Simuler la collecte de métadonnées d'un appel téléphonique
def collect_call_metadata():
    sender = "06 11 22 33 44"
    receiver = input("Entrez le numéro du destinataire de l'appel : ")
    duration = input("Entrez la durée de l'appel en secondes : ")
    timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    
    # Stocker les métadonnées de l'appel
    store_metadata("appel", sender, receiver, timestamp, duration=duration)

# Simuler la collecte de métadonnées d'un SMS avec chiffrement AES
def collect_sms_metadata():
    sender = "06 11 22 33 44"
    receiver = input("Entrez le numéro du destinataire du SMS : ")
    sms_content = input("Entrez le contenu du SMS : ")
    timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

    # Chiffrer le SMS avec AES
    encrypted_content = encrypt_message_aes(sms_content)
    
    # Stocker les métadonnées du SMS avec chiffrement AES
    store_metadata("sms", sender, receiver, timestamp, sms_content=encrypted_content)

# Fonction pour capturer les paquets réseau (exemple sur l'interface eth0)
def packet_callback(packet):
    print(packet.summary())

def capture_traffic(interface="eth0", duration=10):
    print(f"Début de la capture de paquets sur {interface} pour {duration} secondes...")
    sniff(iface=interface, prn=packet_callback, timeout=duration)

# Fonction pour envoyer une alerte par email
def send_alert(subject, message):
    msg = MIMEText(message)
    msg['Subject'] = subject
    msg['From'] = "alert@telecomsystem.com"
    msg['To'] = "admin@yourdomain.com"
    
    # Configuration SMTP (à adapter avec votre serveur mail)
    s = smtplib.SMTP('localhost')
    s.send_message(msg)
    s.quit()

# Détection d'anomalies dans les communications (par exemple, plus de 100 appels en 10 minutes)
def detect_anomalies():
    try:
        with open(COMM_FILE, 'r') as file:
            data = json.load(file)
            recent_communications = [
                entry for entry in data if datetime.datetime.strptime(entry['timestamp'], '%Y-%m-%d %H:%M:%S') >= datetime.datetime.now() - datetime.timedelta(minutes=10)
            ]
            if len(recent_communications) > 100:  # Seuil d'alerte : plus de 100 appels en 10 minutes
                send_alert("Anomalie détectée", f"Un pic d'activité anormal de {len(recent_communications)} appels a été détecté.")
    except FileNotFoundError:
        print("Le fichier de communications est introuvable.")

# Statistiques d'appels/messages
def plot_call_stats():
    try:
        with open(COMM_FILE, 'r') as file:
            data = json.load(file)
            if not data:
                print("Aucune donnée pour les statistiques.")
                return
            times = [datetime.datetime.strptime(entry['timestamp'], '%Y-%m-%d %H:%M:%S') for entry in data]
            plt.hist(times, bins=10)
            plt.xlabel("Temps")
            plt.ylabel("Nombre de communications")
            plt.title("Statistiques des communications")
            plt.show()
    except FileNotFoundError:
        print("Le fichier de communications est introuvable.")

# Threading pour exécuter des tâches en parallèle (par exemple, capture réseau et détection d'anomalies)
def start_monitoring():
    # Lancer la capture de paquets réseau en arrière-plan
    network_thread = threading.Thread(target=capture_traffic, args=("eth0", 30))
    network_thread.start()

    # Lancer la détection d'anomalies en arrière-plan
    anomaly_thread = threading.Thread(target=detect_anomalies)
    anomaly_thread.start()

    network_thread.join()
    anomaly_thread.join()

# Programme principal
if __name__ == "__main__":
    print("Système de Gestion des Communications Téléphoniques (Kali Linux Edition)\n")

    while True:
        print("1. Ajouter un appel téléphonique")
        print("2. Ajouter un SMS")
        print("3. Afficher les métadonnées des communications")
        print("4. Voir les statistiques des appels/SMS")
        print("5. Démarrer le monitoring en temps réel")
        print("6. Quitter")

        choix = input("Choisissez une option : ")

        if choix == "1":
            collect_call_metadata()
        elif choix == "2":
            collect_sms_metadata()
        elif choix == "3":
            list_metadata()
        elif choix == "4":
            plot_call_stats()
        elif choix == "5":
            start_monitoring()
        elif choix == "6":
            break
        else:
            print("Option invalide, veuillez réessayer.")

Manuel d'Utilisation

Lancer le Programme :

Pour exécuter le programme sur Kali Linux, ouvrez un terminal et lancez :

python gestion_communications_kali.py

Options Disponibles :

• 1 : Ajouter un appel téléphonique. Saisissez le numéro et la durée.
• 2 : Ajouter un SMS chiffré avec AES. Saisissez le contenu du message, qui sera ensuite chiffré.
• 3 : Afficher toutes les métadonnées enregistrées.
• 4 : Voir un graphique statistique des communications avec Matplotlib.
• 5 : Lancer la surveillance réseau (capture de paquets) et la détection d’anomalies en parallèle.
• 6 : Quitter le programme.

Personnalisation :

Vous pouvez personnaliser le chiffrement AES, ajuster les interfaces réseau pour la capture des paquets, et adapter les alertes d'anomalies en fonction de vos besoins spécifiques.

Attention :

Veuillez utiliser ce programme exclusivement sur des téléphones ou des systèmes dont vous êtes propriétaire ou pour lesquels vous avez obtenu une autorisation explicite. Toute utilisation non autorisée à des fins de surveillance ou d'interception constitue une violation de la vie privée et est illégale. Ce projet est destiné à des usages éducatifs et éthiques conformément aux lois en vigueur.